#!/usr/bin/python
# Copyright (c) Ansible Project
# GNU General Public License v3.0+ (see LICENSES/GPL-3.0-or-later.txt or https://www.gnu.org/licenses/gpl-3.0.txt)
# SPDX-License-Identifier: GPL-3.0-or-later

from __future__ import annotations

DOCUMENTATION = r"""
module: oneandone_load_balancer
short_description: Configure 1&1 load balancer
description:
  - Create, remove, update load balancers. This module has a dependency on 1and1 >= 1.0.
deprecated:
  removed_in: 13.0.0
  why: DNS fails to resolve the API endpoint used by the module.
  alternative: There is none.
extends_documentation_fragment:
  - community.general.attributes
attributes:
  check_mode:
    support: full
  diff_mode:
    support: none
options:
  state:
    description:
      - Define a load balancer state to create, remove, or update.
    type: str
    default: 'present'
    choices: ["present", "absent", "update"]
  auth_token:
    description:
      - Authenticating API token provided by 1&1.
    type: str
  load_balancer:
    description:
      - The identifier (id or name) of the load balancer used with update state.
    type: str
  api_url:
    description:
      - Custom API URL. Overrides the E(ONEANDONE_API_URL) environment variable.
    type: str
  name:
    description:
      - Load balancer name used with present state. Used as identifier (ID or name) when used with absent state. maxLength=128.
    type: str
  health_check_test:
    description:
      - Type of the health check. At the moment, HTTP is not allowed.
    type: str
    choices: ["NONE", "TCP", "HTTP", "ICMP"]
  health_check_interval:
    description:
      - Health check period in seconds. minimum=5, maximum=300, multipleOf=1.
    type: str
  health_check_path:
    description:
      - URL to call for checking. Required for HTTP health check. maxLength=1000.
    type: str
  health_check_parse:
    description:
      - Regular expression to check. Required for HTTP health check. maxLength=64.
    type: str
  persistence:
    description:
      - Persistence.
    type: bool
  persistence_time:
    description:
      - Persistence time in seconds. Required if persistence is enabled. minimum=30, maximum=1200, multipleOf=1.
    type: str
  method:
    description:
      - Balancing procedure.
    type: str
    choices: ["ROUND_ROBIN", "LEAST_CONNECTIONS"]
  datacenter:
    description:
      - ID or country code of the datacenter where the load balancer is created.
      - If not specified, it defaults to V(US).
    type: str
    choices: ["US", "ES", "DE", "GB"]
  rules:
    description:
      - A list of rule objects that are set for the load balancer. Each rule must contain protocol, port_balancer, and port_server
        parameters, in addition to source parameter, which is optional.
    type: list
    elements: dict
    default: []
  description:
    description:
      - Description of the load balancer. maxLength=256.
    type: str
  add_server_ips:
    description:
      - A list of server identifiers (id or name) to be assigned to a load balancer. Used in combination with O(state=update).
    type: list
    elements: str
    default: []
  remove_server_ips:
    description:
      - A list of server IP IDs to be unassigned from a load balancer. Used in combination with O(state=update).
    type: list
    elements: str
    default: []
  add_rules:
    description:
      - A list of rules that are added to an existing load balancer. It is syntax is the same as the one used for rules parameter.
        Used in combination with O(state=update).
    type: list
    elements: dict
    default: []
  remove_rules:
    description:
      - A list of rule IDs that are removed from an existing load balancer. Used in combination with O(state=update).
    type: list
    elements: str
    default: []
  wait:
    description:
      - Wait for the instance to be in state 'running' before returning.
    default: true
    type: bool
  wait_timeout:
    description:
      - How long before wait gives up, in seconds.
    type: int
    default: 600
  wait_interval:
    description:
      - Defines the number of seconds to wait when using the _wait_for methods.
    type: int
    default: 5

requirements:
  - "1and1"

author:
  - Amel Ajdinovic (@aajdinov)
  - Ethan Devenport (@edevenport)
"""

EXAMPLES = r"""
- name: Create a load balancer
  community.general.oneandone_load_balancer:
    auth_token: oneandone_private_api_key
    name: ansible load balancer
    description: Testing creation of load balancer with ansible
    health_check_test: TCP
    health_check_interval: 40
    persistence: true
    persistence_time: 1200
    method: ROUND_ROBIN
    datacenter: US
    rules:
      - protocol: TCP
        port_balancer: 80
        port_server: 80
        source: 0.0.0.0
    wait: true
    wait_timeout: 500

- name: Destroy a load balancer
  community.general.oneandone_load_balancer:
    auth_token: oneandone_private_api_key
    name: ansible load balancer
    wait: true
    wait_timeout: 500
    state: absent

- name: Update a load balancer
  community.general.oneandone_load_balancer:
    auth_token: oneandone_private_api_key
    load_balancer: ansible load balancer
    name: ansible load balancer updated
    description: Testing the update of a load balancer with ansible
    wait: true
    wait_timeout: 500
    state: update

- name: Add server to a load balancer
  community.general.oneandone_load_balancer:
    auth_token: oneandone_private_api_key
    load_balancer: ansible load balancer updated
    description: Adding server to a load balancer with ansible
    add_server_ips:
      - server identifier (id or name)
    wait: true
    wait_timeout: 500
    state: update

- name: Remove server from a load balancer
  community.general.oneandone_load_balancer:
    auth_token: oneandone_private_api_key
    load_balancer: ansible load balancer updated
    description: Removing server from a load balancer with ansible
    remove_server_ips:
      - B2504878540DBC5F7634EB00A07C1EBD (server's ip id)
    wait: true
    wait_timeout: 500
    state: update

- name: Add rules to a load balancer
  community.general.oneandone_load_balancer:
    auth_token: oneandone_private_api_key
    load_balancer: ansible load balancer updated
    description: Adding rules to a load balancer with ansible
    add_rules:
      - protocol: TCP
        port_balancer: 70
        port_server: 70
        source: 0.0.0.0
      - protocol: TCP
        port_balancer: 60
        port_server: 60
        source: 0.0.0.0
    wait: true
    wait_timeout: 500
    state: update

- name: Remove rules from a load balancer
  community.general.oneandone_load_balancer:
    auth_token: oneandone_private_api_key
    load_balancer: ansible load balancer updated
    description: Adding rules to a load balancer with ansible
    remove_rules:
      - "rule_id #1"
      - "rule_id #2"
      - '...'
    wait: true
    wait_timeout: 500
    state: update
"""

RETURN = r"""
load_balancer:
  description: Information about the load balancer that was processed.
  type: dict
  sample: {"id": "92B74394A397ECC3359825C1656D67A6", "name": "Default Balancer"}
  returned: always
"""

import os
from ansible.module_utils.basic import AnsibleModule
from ansible_collections.community.general.plugins.module_utils.oneandone import (
    get_load_balancer,
    get_server,
    get_datacenter,
    OneAndOneResources,
    wait_for_resource_creation_completion,
)

HAS_ONEANDONE_SDK = True

try:
    import oneandone.client
except ImportError:
    HAS_ONEANDONE_SDK = False

DATACENTERS = ["US", "ES", "DE", "GB"]
HEALTH_CHECK_TESTS = ["NONE", "TCP", "HTTP", "ICMP"]
METHODS = ["ROUND_ROBIN", "LEAST_CONNECTIONS"]


def _check_mode(module, result):
    if module.check_mode:
        module.exit_json(changed=result)


def _add_server_ips(module, oneandone_conn, load_balancer_id, server_ids):
    """
    Assigns servers to a load balancer.
    """
    try:
        attach_servers = []

        for server_id in server_ids:
            server = get_server(oneandone_conn, server_id, True)
            attach_server = oneandone.client.AttachServer(
                server_id=server["id"], server_ip_id=next(iter(server["ips"] or []), None)["id"]
            )
            attach_servers.append(attach_server)

        if module.check_mode:
            return bool(attach_servers)

        load_balancer = oneandone_conn.attach_load_balancer_server(
            load_balancer_id=load_balancer_id, server_ips=attach_servers
        )
        return load_balancer
    except Exception as ex:
        module.fail_json(msg=str(ex))


def _remove_load_balancer_server(module, oneandone_conn, load_balancer_id, server_ip_id):
    """
    Unassigns a server/IP from a load balancer.
    """
    try:
        if module.check_mode:
            lb_server = oneandone_conn.get_load_balancer_server(
                load_balancer_id=load_balancer_id, server_ip_id=server_ip_id
            )
            return bool(lb_server)

        load_balancer = oneandone_conn.remove_load_balancer_server(
            load_balancer_id=load_balancer_id, server_ip_id=server_ip_id
        )
        return load_balancer
    except Exception as ex:
        module.fail_json(msg=str(ex))


def _add_load_balancer_rules(module, oneandone_conn, load_balancer_id, rules):
    """
    Adds new rules to a load_balancer.
    """
    try:
        load_balancer_rules = []

        for rule in rules:
            load_balancer_rule = oneandone.client.LoadBalancerRule(
                protocol=rule["protocol"],
                port_balancer=rule["port_balancer"],
                port_server=rule["port_server"],
                source=rule["source"],
            )
            load_balancer_rules.append(load_balancer_rule)

        if module.check_mode:
            lb_id = get_load_balancer(oneandone_conn, load_balancer_id)
            return bool(load_balancer_rules and lb_id)

        load_balancer = oneandone_conn.add_load_balancer_rule(
            load_balancer_id=load_balancer_id, load_balancer_rules=load_balancer_rules
        )

        return load_balancer
    except Exception as ex:
        module.fail_json(msg=str(ex))


def _remove_load_balancer_rule(module, oneandone_conn, load_balancer_id, rule_id):
    """
    Removes a rule from a load_balancer.
    """
    try:
        if module.check_mode:
            rule = oneandone_conn.get_load_balancer_rule(load_balancer_id=load_balancer_id, rule_id=rule_id)
            return bool(rule)

        load_balancer = oneandone_conn.remove_load_balancer_rule(load_balancer_id=load_balancer_id, rule_id=rule_id)
        return load_balancer
    except Exception as ex:
        module.fail_json(msg=str(ex))


def update_load_balancer(module, oneandone_conn):
    """
    Updates a load_balancer based on input arguments.
    Load balancer rules and server ips can be added/removed to/from
    load balancer. Load balancer name, description, health_check_test,
    health_check_interval, persistence, persistence_time, and method
    can be updated as well.

    module : AnsibleModule object
    oneandone_conn: authenticated oneandone object
    """
    load_balancer_id = module.params.get("load_balancer")
    name = module.params.get("name")
    description = module.params.get("description")
    health_check_test = module.params.get("health_check_test")
    health_check_interval = module.params.get("health_check_interval")
    health_check_path = module.params.get("health_check_path")
    health_check_parse = module.params.get("health_check_parse")
    persistence = module.params.get("persistence")
    persistence_time = module.params.get("persistence_time")
    method = module.params.get("method")
    add_server_ips = module.params.get("add_server_ips")
    remove_server_ips = module.params.get("remove_server_ips")
    add_rules = module.params.get("add_rules")
    remove_rules = module.params.get("remove_rules")

    changed = False

    load_balancer = get_load_balancer(oneandone_conn, load_balancer_id, True)
    if load_balancer is None:
        _check_mode(module, False)

    if (
        name
        or description
        or health_check_test
        or health_check_interval
        or health_check_path
        or health_check_parse
        or persistence
        or persistence_time
        or method
    ):
        _check_mode(module, True)
        load_balancer = oneandone_conn.modify_load_balancer(
            load_balancer_id=load_balancer["id"],
            name=name,
            description=description,
            health_check_test=health_check_test,
            health_check_interval=health_check_interval,
            health_check_path=health_check_path,
            health_check_parse=health_check_parse,
            persistence=persistence,
            persistence_time=persistence_time,
            method=method,
        )
        changed = True

    if add_server_ips:
        if module.check_mode:
            _check_mode(module, _add_server_ips(module, oneandone_conn, load_balancer["id"], add_server_ips))

        load_balancer = _add_server_ips(module, oneandone_conn, load_balancer["id"], add_server_ips)
        changed = True

    if remove_server_ips:
        chk_changed = False
        for server_ip_id in remove_server_ips:
            if module.check_mode:
                chk_changed |= _remove_load_balancer_server(module, oneandone_conn, load_balancer["id"], server_ip_id)

            _remove_load_balancer_server(module, oneandone_conn, load_balancer["id"], server_ip_id)
        _check_mode(module, chk_changed)
        load_balancer = get_load_balancer(oneandone_conn, load_balancer["id"], True)
        changed = True

    if add_rules:
        load_balancer = _add_load_balancer_rules(module, oneandone_conn, load_balancer["id"], add_rules)
        _check_mode(module, load_balancer)
        changed = True

    if remove_rules:
        chk_changed = False
        for rule_id in remove_rules:
            if module.check_mode:
                chk_changed |= _remove_load_balancer_rule(module, oneandone_conn, load_balancer["id"], rule_id)

            _remove_load_balancer_rule(module, oneandone_conn, load_balancer["id"], rule_id)
        _check_mode(module, chk_changed)
        load_balancer = get_load_balancer(oneandone_conn, load_balancer["id"], True)
        changed = True

    try:
        return (changed, load_balancer)
    except Exception as ex:
        module.fail_json(msg=str(ex))


def create_load_balancer(module, oneandone_conn):
    """
    Create a new load_balancer.

    module : AnsibleModule object
    oneandone_conn: authenticated oneandone object
    """
    try:
        name = module.params.get("name")
        description = module.params.get("description")
        health_check_test = module.params.get("health_check_test")
        health_check_interval = module.params.get("health_check_interval")
        health_check_path = module.params.get("health_check_path")
        health_check_parse = module.params.get("health_check_parse")
        persistence = module.params.get("persistence")
        persistence_time = module.params.get("persistence_time")
        method = module.params.get("method")
        datacenter = module.params.get("datacenter")
        rules = module.params.get("rules")
        wait = module.params.get("wait")
        wait_timeout = module.params.get("wait_timeout")
        wait_interval = module.params.get("wait_interval")

        load_balancer_rules = []

        datacenter_id = None
        if datacenter is not None:
            datacenter_id = get_datacenter(oneandone_conn, datacenter)
            if datacenter_id is None:
                module.fail_json(msg=f"datacenter {datacenter} not found.")

        for rule in rules:
            load_balancer_rule = oneandone.client.LoadBalancerRule(
                protocol=rule["protocol"],
                port_balancer=rule["port_balancer"],
                port_server=rule["port_server"],
                source=rule["source"],
            )
            load_balancer_rules.append(load_balancer_rule)

        _check_mode(module, True)
        load_balancer_obj = oneandone.client.LoadBalancer(
            health_check_path=health_check_path,
            health_check_parse=health_check_parse,
            name=name,
            description=description,
            health_check_test=health_check_test,
            health_check_interval=health_check_interval,
            persistence=persistence,
            persistence_time=persistence_time,
            method=method,
            datacenter_id=datacenter_id,
        )

        load_balancer = oneandone_conn.create_load_balancer(
            load_balancer=load_balancer_obj, load_balancer_rules=load_balancer_rules
        )

        if wait:
            wait_for_resource_creation_completion(
                oneandone_conn, OneAndOneResources.load_balancer, load_balancer["id"], wait_timeout, wait_interval
            )

        load_balancer = get_load_balancer(oneandone_conn, load_balancer["id"], True)  # refresh
        changed = True if load_balancer else False

        _check_mode(module, False)

        return (changed, load_balancer)
    except Exception as ex:
        module.fail_json(msg=str(ex))


def remove_load_balancer(module, oneandone_conn):
    """
    Removes a load_balancer.

    module : AnsibleModule object
    oneandone_conn: authenticated oneandone object
    """
    try:
        lb_id = module.params.get("name")
        load_balancer_id = get_load_balancer(oneandone_conn, lb_id)
        if module.check_mode:
            if load_balancer_id is None:
                _check_mode(module, False)
            _check_mode(module, True)
        load_balancer = oneandone_conn.delete_load_balancer(load_balancer_id)

        changed = True if load_balancer else False

        return (changed, {"id": load_balancer["id"], "name": load_balancer["name"]})
    except Exception as ex:
        module.fail_json(msg=str(ex))


def main():
    module = AnsibleModule(
        argument_spec=dict(
            auth_token=dict(type="str", no_log=True, default=os.environ.get("ONEANDONE_AUTH_TOKEN")),
            api_url=dict(type="str", default=os.environ.get("ONEANDONE_API_URL")),
            load_balancer=dict(type="str"),
            name=dict(type="str"),
            description=dict(type="str"),
            health_check_test=dict(choices=HEALTH_CHECK_TESTS),
            health_check_interval=dict(type="str"),
            health_check_path=dict(type="str"),
            health_check_parse=dict(type="str"),
            persistence=dict(type="bool"),
            persistence_time=dict(type="str"),
            method=dict(choices=METHODS),
            datacenter=dict(choices=DATACENTERS),
            rules=dict(type="list", elements="dict", default=[]),
            add_server_ips=dict(type="list", elements="str", default=[]),
            remove_server_ips=dict(type="list", elements="str", default=[]),
            add_rules=dict(type="list", elements="dict", default=[]),
            remove_rules=dict(type="list", elements="str", default=[]),
            wait=dict(type="bool", default=True),
            wait_timeout=dict(type="int", default=600),
            wait_interval=dict(type="int", default=5),
            state=dict(type="str", default="present", choices=["present", "absent", "update"]),
        ),
        supports_check_mode=True,
    )

    if not HAS_ONEANDONE_SDK:
        module.fail_json(msg="1and1 required for this module")

    if not module.params.get("auth_token"):
        module.fail_json(msg="auth_token parameter is required.")

    if not module.params.get("api_url"):
        oneandone_conn = oneandone.client.OneAndOneService(api_token=module.params.get("auth_token"))
    else:
        oneandone_conn = oneandone.client.OneAndOneService(
            api_token=module.params.get("auth_token"), api_url=module.params.get("api_url")
        )

    state = module.params.get("state")

    if state == "absent":
        if not module.params.get("name"):
            module.fail_json(msg="'name' parameter is required for deleting a load balancer.")
        try:
            (changed, load_balancer) = remove_load_balancer(module, oneandone_conn)
        except Exception as ex:
            module.fail_json(msg=str(ex))
    elif state == "update":
        if not module.params.get("load_balancer"):
            module.fail_json(msg="'load_balancer' parameter is required for updating a load balancer.")
        try:
            (changed, load_balancer) = update_load_balancer(module, oneandone_conn)
        except Exception as ex:
            module.fail_json(msg=str(ex))

    elif state == "present":
        for param in (
            "name",
            "health_check_test",
            "health_check_interval",
            "persistence",
            "persistence_time",
            "method",
            "rules",
        ):
            if not module.params.get(param):
                module.fail_json(msg=f"{param} parameter is required for new load balancers.")
        try:
            (changed, load_balancer) = create_load_balancer(module, oneandone_conn)
        except Exception as ex:
            module.fail_json(msg=str(ex))

    module.exit_json(changed=changed, load_balancer=load_balancer)


if __name__ == "__main__":
    main()
